﻿using System;
using System.Collections.Generic;

using System.Text;

namespace Rance.Battle
{
    class 军乐队AI : AI
    {
        public override AIResult Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            int 治疗几率 = 50;

            //50%几率使用其他
            if (队伍状况.战场.AI乱数表.Hit(治疗几率))
            {
                军乐队AI_其他 ai = 军乐队AI_其他.GetInstance();
                return ai.Excute(角色, 队伍状况, 技能mgt);
            }
            else
            {
                军乐队AI_治疗 ai = 军乐队AI_治疗.GetInstance();
                return ai.Excute(角色, 队伍状况, 技能mgt);
            }
        }

        protected AIResult 弓箭射击Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            var 弓箭射击 = 技能mgt.Get("弓箭射击");
            var 弓箭射击target = getTarget(ConvertSoloTarget(弓箭射击.TargetList), 队伍状况, 角色);
            result.Action = 弓箭射击.Name;
            result.TargetList.Add(弓箭射击target);

            return result;

        }

        protected AIResult 其他Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            if (技能mgt.Has("义勇军"))
            {
                var 义勇军 = 技能mgt.Get("义勇军");
                //剩下自己的时候不使用
                if (义勇军.TargetList.Count > 1)
                {
                    var target = get义勇军Target(队伍状况);
                    if (target != null)
                    {
                        result.Action = 义勇军.Name;
                        result.TargetList.Add(target);

                        return result;
                    }
                }
            }

            if (技能mgt.Has("振奋号角"))
            {
                var 振奋号角 = 技能mgt.Get("振奋号角");

                var target = get振奋号角Target(队伍状况);
                if (target != null)
                {
                    result.Action = 振奋号角.Name;
                    result.TargetList.Add(target);
                    return result;
                }
            }

            return null;
        }

        protected AIResult 治疗Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            var 需要治疗List = 队伍状况.队伍.成员List.FindAll(m => !m.是否败退 && !m.是否完结 && ((m.最大兵力 - m.兵力) > 150 || (m.最大兵力 - m.兵力) * 100 / m.最大兵力 > 25));
            bool has高级征兵令 = 技能mgt.Has("高级征兵令");
            if (has高级征兵令 && 需要治疗List.Count >= 2)
            {
                var 高级征兵令 = 技能mgt.Get("高级征兵令");
                result.Action = 高级征兵令.Name;
                result.TargetList = 高级征兵令.TargetList[0].List;

                return result;
            }

            if (需要治疗List.Count > 0)
            {
                需要治疗List.Sort((v1, v2) => (v1.最大兵力 - v1.兵力).CompareTo((v2.最大兵力 - v2.兵力)));
                需要治疗List.Reverse();

                if (技能mgt.Has("医仙降临"))
                {
                    if (需要治疗List[0].兵力 >= 250 ||
                      (需要治疗List[0].最大兵力 - 需要治疗List[0].兵力) <= 250 ||
                       需要治疗List.Count <= 2)
                    {
                        var 医仙降临 = 技能mgt.Get("医仙降临");
                        result.Action = 医仙降临.Name;
                        result.TargetList.Add(角色);

                        return result;
                    }
                }

                if (技能mgt.Has("征兵令"))
                {
                    var 征兵令 = 技能mgt.Get("征兵令");
                    result.Action = 征兵令.Name;
                    result.TargetList.Add(需要治疗List[0]);

                    return result;
                }
            }

            return null;
        }

        private 角色 get义勇军Target(队伍状况 队伍状况)
        {
            var 前排list = 队伍状况.队伍.成员List.FindAll(m => !m.是否败退 && !m.是否完结 && m.列 == 1 && m.技能自动恢复 == 0);
            var 全体list = 队伍状况.队伍.成员List.FindAll(m => !m.是否败退 && !m.是否完结 && m.技能自动恢复 == 0);
            var list = 前排list.Count == 0 ? 全体list : 前排list;

            if (list.Count > 0)
            {
                list.Sort((v1, v2) => v1.行动点.CompareTo(v2.行动点));
                return list[list.Count - 1];
            }

            return null;
        }

        private 角色 get振奋号角Target(队伍状况 队伍状况)
        {
            List<角色> list = new List<角色>();
            foreach (var item in 队伍状况.队伍.成员List)
            {
                if (item.是否败退 || item.是否完结)
                    continue;

                if (item.技能物理吸血 > 0)
                    continue;

                if (item.兵种.类型 == "剑士" &&
                   item.兵种.类型 == "骑兵" &&
                   item.兵种.类型 == "侠客" &&
                   item.兵种.类型 == "弓兵" &&
                   item.兵种.类型 == "火枪" &&
                   item.兵种.类型 == "战车" &&
                   item.兵种.类型 == "炮兵")
                    list.Add(item);
            }

            if (list.Count == 0)
                return null;

            list.Sort((v1, v2) =>
            {
                var result = v1.列.CompareTo(v2.列);
                if (result == 0)
                    return v2.攻.CompareTo(v1.攻);
                else
                    return result;
            });
            return list[0];
        }

        private 角色 getTarget(List<角色> targetList, 队伍状况 队伍状况, 角色 角色)
        {
            //优先攻击"准备中"的敌人
            List<角色> tempList = targetList.FindAll(r => r.是否准备);
            if (tempList.Count == 1)
                return targetList[0];
            else if (tempList.Count > 1)
            {
                var value = 队伍状况.战场.AI乱数表.Random(0, tempList.Count);
                return tempList[value];
            }

            //撇除"步卒"敌人
            tempList.Clear();
            foreach (var item in targetList)
            {
                if (item.兵种.类型 == "步卒")
                    continue;

                tempList.Add(item);
            }

            if (tempList.Count != 0)
                targetList = tempList;

            if (targetList.Count == 1)
                return targetList[0];
            else
            {
                //优先攻击准备中的敌人

                List<角色> temp2List = new List<角色>();
                foreach (var item in tempList)
                {
                    if (item.是否准备)
                    {
                        tempList.Add(item);
                        break;
                    }
                }
                if (temp2List.Count == 1)
                    return temp2List[0];

                var value = 队伍状况.战场.AI乱数表.Random(0, targetList.Count);
                return targetList[value];
            }
        }

        private static 军乐队AI instance = new 军乐队AI();
        public static 军乐队AI GetInstance()
        {
            return instance;
        }
    }
}
